package demo1;
class Animal{
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(name+"吃饭");
    }

    //三个块 静态代码块 非静态代码块 构造块
    //先执行静态代码块 再非静态代码块 后构造块
    //且静态代码块只执行一次
    /*static{
        System.out.println("Animal的静态代码块");
    }*/
   /* {
        System.out.println("Animal的实例化代码块");
    }*/
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Animal(String)");
    }


}
//子类继父类后 可以继承父类的成员和方法

//当子类继承父类后，一定要先帮助父类进行构造再构造子类自己  只能在子类中调用父类方法
class Dog extends Animal{
   /* static{
        System.out.println("Dog的静态代码块");
    }*/
    /*{
        System.out.println("Dog的实例代码块");
    }*/
    public Dog(String name,int age){
        super(name,age);//调用你想调用的方法
        System.out.println("Dog的构造方法");
    }//执行完这个}后子类方法构造完了
    public void wangwang(){
        System.out.println(name+"wang!!");
    }
    public void  eat(){
        System.out.println("吃狗粮！");
    }

}
class Cat extends Animal{
    public Cat(String name,int age){
        super(name,age);
        //this();//this()和super()不能同时岑仔 因为两者都要求放在构造函数的第一条
    }
    public void miaomiao(){
        System.out.println(name+"miao~");
    }

}
class Bird extends Animal{
    public Bird(String name, int age){
        super(name,age);
    }
    public void fly(){
        System.out.println("正在飞");
    }
}
/*class Dog{
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(name+"吃饭");
    }
    public void wangwang(){
        System.out.println(name+"wang!!");
    }
}*/

/*class Cat{
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(name+"在吃罐罐");
    }
    public void miaomiao(){
        System.out.println(name+"miao~");
    }

}*/
public class Test {
    public static void main(String[] args) {
        Animal animal2 = new Bird("小鸟",10);
        //向下转型 但是不安全
        Bird bird = (Bird)animal2;
        bird.fly();
        Animal animal1 = new Dog("小狗",20);
        if(animal1 instanceof Bird){ //判断是否引用了这么一个类型的对象
            Bird bird2 = (Bird) animal1;
            bird2.fly();
        }else{
            System.out.println("不能飞");
        }
    }


    //向上转型有三种方式
    //1.直接赋值
    //2.方法传参的方式
    //3.返回值
    //向上转型的缺点是 不能调用到子类特有的方法

    public static void main3(String[] args) {
        //父类对象引用了的子类对象
        //直接赋值
       Animal animal1 = new Dog("蚂蚁",10);
       Animal animal2 = new Bird("小鸟",20);
       //方法传参方式
       Dog dog = new Dog("小狗",10);
       Bird bird = new Bird("小鸟",10);

       func1(dog);
       func2(bird);
        animal1.eat();
        /*Dog dog1 = new Dog("小黑");
        Animal animal = dog1;*/
        //父类引用引用了一个子类对象
        //Animal animal = new Dog("小蚂蚁");
       // Animal animal1 = new Animal("蚂蚁");
        //animal1.eat();//父类调用父类方法
        //animal1.wangwang(); 不能调用 wangwang（）是子类方法
    }
    //返回值方式
    public static Animal fun2(){
        /*Bird bird = new Bird("小鸟",10);
        return bird;*/
        return new Bird("小鸟",10);
    }

    public  static void func1(Animal animal){

    }
    public  static void func2(Animal animal){

    }
   /* public static void main2(String[] args) {
       *//* Animal animal = new Animal("animal");
        System.out.println("========");
        Animal animal2 = new Animal("animal");*//*//只输出了非静态代码块
        System.out.println("------------");
        Dog dog1 = new Dog("小黑");//父类和子类的静态代码块先执行然后是父类的示例代码块和构造方法最后是子类的示例代码块和构造方法
        System.out.println("=========");
        Dog dog2 = new Dog("小红") ;//第二次不再执行父类和子类的静态代码块

    }
    public static void main1(String[] args) {
        Dog dog = new Dog("小黑");
        dog.eat();
        dog.wangwang();

        Cat cat = new Cat("滑滑");
        cat.eat();
        cat.miaomiao();
    }*/
}
